#include <bits/stdc++.h>
using namespace std;

/* 题意：我们定义，一个"好整数" X 需要满足：X mod (X 的各个数位的和) == 0。
   一对好整数（孪生好整数） (a, a+1) 需要满足 a 和 a+1 都是好整数。
   给定 N（可能有十万位），输出一个满足 N <= a < 2N
   的孪生好整数。如果不存在，输出 -1。

   题解：首先需要知道两件事情：
   - 一个数字是 8 的倍数，当且仅当它的最后三位可以被 8 整除。
   - 一个数字是 9 的倍数，当且仅当它的各个数位加起来能被 9 整除。

   并且观察到，如果不发生进位（最后一位不是 9），那么在 +1 后数位和也恰好 +1。
   因此可以考虑，让 a 的数位和是 8，同时 a 是 8 的倍数且 a 的最后一位不是 9，
   那么 a+1 的数位和就会是 9，我们只需要让 a+1 是 9 的倍数即可。

   整理后条件如下：
   - a 的最后三位可以被 8 整除（设为 000 即可）
   - a 的数位和为 8（此时 a+1 的数位和一定是 9！）
   - N <= a < 2N

   我们其实只需要这两个条件就够了！

   分类讨论，假设输入的数字为 N：
   - 情况一：如果 N = X 0 00000000000000：
       子情况 1：如果 X != 9，可以构造 a = X 8-X 00000000000000
       子情况 2：如果 X = 9，可以构造 a = 1 7 0 00000000000000
   - 情况二：如果 N = X Y ??????????????
       子情况 1： a = X 8-X 00000000000000 （8-X > Y 且 X != 9 时适用）
       子情况 2：如果 a = 1 7 0 00000000000000（X == 9 时适用）
       子情况 3： a = X+1 8-X-1 0000000000000（X < 8 且 X != 1）（或者 X == 1 且
   Y >= 5） 子情况 4： a = 1 0 7 00000000000000（X == 8）
   - 情况三（小情况）：如果 N 比较小，暴力
*/

// 计算一个整数的各位数字之和
int get_digit_sum(int x) {
  int ans = 0;
  while (x) {
    ans += x % 10; // 取最后一位数字并累加
    x /= 10;       // 去掉最后一位数字
  }
  return ans;
}

// 判断一个整数是否为"好整数"
bool is_good(int x) {
  return x % get_digit_sum(x) == 0; // 检查x是否能被其各位数字之和整除
}

// 打印n个0
void print0(int n) {
  for (int i = 1; i <= n; ++i)
    putchar('0');
}

int main() {
  string N;
  cin >> N;

  // 情况三：当N的位数小于等于7时，使用暴力解法
  if (N.length() <= 7) {
    int n = stoi(N); // 将字符串转换为整数
    // 在区间[n, 2n)内寻找孪生好整数
    for (int a = n; a < 2 * n; ++a)
      if (is_good(a) && is_good(a + 1)) { // 检查a和a+1是否都是好整数
        cout << a << endl;
        return 0;
      }
    // 如果没有找到，输出-1
    cout << -1 << endl;
    return 0;
  }

  // 检查N中除了第一位之外是否有非零数字
  bool have_nonzero = false;
  for (int i = 1; i < N.length(); ++i) {
    if (N[i] != '0') {
      have_nonzero = true;
      break;
    }
  }

  // 情况一：N的形式为X后面跟着全0（除了第一位外都是0）
  if (!have_nonzero) {
    int X = N[0] - '0'; // 获取第一位数字
    if (X != 9) {
      // 子情况1：X不等于9，构造a = X (8-X) 后面跟0
      // 这样构造出的数满足：
      // 1. 数位和为 X + (8-X) = 8，满足第一个条件
      // 2. 最后三位是000，能被8整除，满足第二个条件
      printf("%d%d", X, 8 - X);
      print0(N.length() - 2); // 打印剩余位数的0
    } else {
      // 子情况2：X等于9，构造a = 17后面跟0
      // 这样构造出的数满足：
      // 1. 数位和为 1 + 7 = 8，满足第一个条件
      // 2. 最后三位是000，能被8整除，满足第二个条件
      printf("17");
      print0(N.length() - 1); // 打印剩余位数的0
    }
  }
  // 情况二：N的形式为XY后面跟着其他数字（除了第一位外有非零数字）
  else {
    int X = N[0] - '0'; // 获取第一位数字
    int Y = N[1] - '0'; // 获取第二位数字

    // 根据不同的X值进行分类处理
    if (X == 8) {
      // 子情况4：X等于8，构造a = 107后面跟0
      // 这样构造出的数满足：
      // 1. 数位和为 1 + 0 + 7 = 8，满足第一个条件
      // 2. 最后三位是700，能被8整除(700 % 8 = 4...4)，实际上应该是000
      //    但这里的构造方式是107...000，所以最后三位是000，满足第二个条件
      printf("107");
      print0(N.length() - 2);
    } else if (X == 9) {
      // 子情况2：X等于9，构造a = 17后面跟0
      // 这样构造出的数满足：
      // 1. 数位和为 1 + 7 = 8，满足第一个条件
      // 2. 最后三位是000，能被8整除，满足第二个条件
      printf("17");
      print0(N.length() - 1);
    } else if (X != 1 || (X == 1 && Y >= 5)) {
      // 子情况3：X不等于1，或者X等于1且Y>=5，构造a = (X+1)(8-X-1)后面跟0
      // 这样构造出的数满足：
      // 1. 数位和为 (X+1) + (8-X-1) = 8，满足第一个条件
      // 2. 最后三位是000，能被8整除，满足第二个条件
      printf("%d%d", X + 1, 8 - X - 1);
      print0(N.length() - 2);
    } else {
      // 现在只剩下 X == 1 而且 Y < 5 的情况，构造a = 17后面跟0
      // 这样构造出的数满足：
      // 1. 数位和为 1 + 7 = 8，满足第一个条件
      // 2. 最后三位是000，能被8整除，满足第二个条件
      printf("17");
      print0(N.length() - 2);
    }
  }
  return 0;
}